#include <bits/stdc++.h>
using namespace std;

#define ONLINE_JUDGE

#ifndef ONLINE_JUDGE
#define dbg(x...) { cerr << "\033[32;1m" << #x << " -> "; err(x); }
void err() { cerr << "\033[39;0m" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cerr << a << ' '; err(x...); }
#else
#define dbg(...)
#endif

const int N = 2e5 + 50;

typedef long long LL;

struct node
{
	int id;
	LL v;
	node (int id=0, LL v=0)
	:id(id), v(v)
	{}

	bool operator < (const node &other) const
	{
		if (v != other.v)
			return v < other.v;
		else
			return id < other.id;
	}
};



struct segT
{
	node dat[N << 2];

	LL lazy[N << 2];

	int nn, L, R;

	inline void pu(int rt)
	{
		dat[rt] = max(dat[rt << 1], dat[rt << 1 | 1]);
	}


	inline void pd(int rt)
	{
		if (lazy[rt])
		{
			int ls = rt << 1, rs = rt << 1 | 1;
			lazy[ls] += lazy[rt];
			dat[ls].v += lazy[rt];
			lazy[rs] += lazy[rt];
			dat[rs].v += lazy[rt];
			lazy[rt] = 0;
		}
	}
	void init(int n, int a[])
	{
		nn = 1;
		while (nn < n) nn <<= 1;
		for (int i=1; i<=n; ++i)
			dat[i+nn-1] = node(i, a[i]);
		for (int i=nn + n; i<2*nn; ++i)
			dat[i] = node(-1, -1e18);
		for (int i=nn-1; i>=1; --i)
			pu(i);
	}

	void u(int l, int r, int rt, int v)
	{
		if (L <= l && r <= R)
		{
			dat[rt].v += v;
			lazy[rt] += v;
			return;
		}
		pd(rt);
		int m = (l + r) >> 1;
		if (L <= m) u(l, m, rt << 1, v);
		if (m+1<=R) u(m+1, r, rt << 1 | 1, v);
		pu(rt);
	}

	node q(int l, int r, int rt)
	{
		// dbg(l, r, rt);
		if (L <= l && r <= R)
		{
			return dat[rt];
		}
		int m = (l+r) >> 1;
		pd(rt);
		node v1(-1, -1e18), v2(-1, -1e18);
		if (L <= m) v1 = q(l, m, rt<<1);
		if (m+1<=R) v2 = q(m+1, r, rt<<1|1);
		pu(rt);
		return max(v1, v2);
	}

	inline void u(int l, int r, int v)
	{
		L = l;
		R = r;
		u(1, nn, 1, v);
	}

	inline node q(int l, int r)
	{
		L = l;
		R = r;
		return q(1, nn, 1);
	}

} seg;

int wcnt, acnt, mcnt;

struct weapon
{
	int v, id, cost;
	bool operator < (const weapon &other) const
	{
		return v < other.v;
	}
} w[N];

struct armor
{
	int v, id, cost;
	bool operator < (const armor &other) const
	{
		return v < other.v;
	}
} a[N];

struct monster
{
	int att, def, fund;
	bool operator < (const monster &other) const 
	{
		return att != other.att ? att < other.att : def < other.def;
	}
} m[N];


int main(int argc, char const *argv[])
{
	scanf("%d%d%d", &wcnt, &acnt, &mcnt);
	for (int i=1; i<=wcnt; ++i)
	{
		scanf("%d%d", &w[i].v, &w[i].cost);
		// --w[i].v;
	}
	for (int i=1; i<=acnt; ++i)
	{
		scanf("%d%d", &a[i].v, &a[i].cost);
		// --a[i].v;
	}

	sort(w+1, w+wcnt+1);
	sort(a+1, a+acnt+1);

	for (int i=1; i<=mcnt; ++i)
	{
		scanf("%d%d%d", &m[i].def, &m[i].att, &m[i].fund);
	}
	sort(m+1, m+mcnt+1);


	{
		static int tmp[N];
		for (int i=1; i<=wcnt; ++i)
		{
			tmp[i] = -w[i].cost;
		}

		seg.init(wcnt, tmp);

		for (int i=1; i<=wcnt; ++i)
			dbg(i, seg.q(i, i).v);	
	}
	// return 0;
	LL ans = -1e18;
	int mop = 1;
	for (int i=1; i<=acnt; ++i)
	{
		LL tans = -a[i].cost;
		dbg(i, tans);
		while (mop <= mcnt && m[mop].att < a[i].v)
		{
			weapon tar;
			tar.v = m[mop].def;
			int p = upper_bound(w+1, w+wcnt+1, tar) - w;
			if (p <= wcnt)
				seg.u(p, wcnt, m[mop].fund);
			dbg(i, mop);
			++mop;
		}
		node qq = seg.q(1, wcnt);
		dbg(qq.id, qq.v);
		tans += qq.v;
		ans = max(ans, tans);
		dbg(i, ans);
	}
	printf("%lld\n", ans);
	return 0;
}